欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页

Java SE：数组

程序员文章站 2022-06-09 22:29:57
...

Java SE：数组

目录

1.一维数组

1.1 定义

  • 相同数据类型数据的有序集合。
  • 存储多个数据，一段连续内存空间

1.2、基本特点

  1. 其长度是确定的。不可以改变的。

  2. 其元素必须是相同类型。

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

  4. 数组属引用数据类型，数组也可以看成是对象。

  5. 有序的 :数组中的每一个空间的序号,从0开始,每次+1–>索引|下标

2、创建数组

2.1 声明数组

  声明数组，就是在声明一个数组类型的变量，变量中并不存在任何的数据。

  • 数据类型[ ] 数组名; ----->建议
  • 数据类型 数组名[ ];
  • 数组中的每一个空间如果没有赋值,存在默认值,由数组的类型决定。
    引用数据类型:null 整数:0 小数:0.0 布尔:false 字符:’ ' 
type[] arr_name;（推荐使用这中方式） 
type arr_name[];

注意：

  • 声明的时候并没有实例化任何对象。
  • 声明一个数组的时候并没有数组被真正的创建。
  • 构造一个数组，必须指定长度。

2.2 构建数组

  • 动态初始化 : 先创建数组,然后再赋值
数据类型[] 数组名 = new 数据类型[数组的长度];
  • 数据类型: 可以为任意数据类型
  • 数组的长度 : 必须为整数,0或者以上的正整数
int[] a = new int[10];
  • 静态初始化 : 创建数组的同时赋值
数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3...};
数据类型[] 数组名 = {数据1,数据2,数据3...};

type变量名[] = new type[]{元素列表}; 
int[] a = new int[]{1,2,3}; // 注意 [] 里边不能再指定长度了 
简写
int[] a1 = {12,3};

  可以省略为: type变量名[] ={元素列表}; 仅在声明和赋值时可以省略

2.3 .数组的长度length

  数组名.length --> 存储数据的个数(小空间的个数) 表示数组的长度。

//查看 数组长度
System.out.println(arr1.length);

2.4 数组界限（下标）

  • 下标的合法区间：[0, length-1]。从0开始,每次+1
  • 所有数组如果有数据,第一个数据空间下标为0
  • 数组的最后一个数据空间索引为: 数组的长度-1
			//声明数组同时赋值
        String[] arr1=new String[]{"haha","heiehi","hehe","ayyay"};
        char[] arr2 =new char[]{'a','c','d'};
        //先创建数组后赋值
        int[] arr3=new int[3];
        arr3[0]=1;
        arr3[1]=2;
        arr3[2]=3;

2.4 操作数组中的数据:

根据索引操作 数组名[ 索引 ]

//查看地址
System.out.println(arr1);
System.out.println(arr3);
System.out.println(arr4);
//查看数组值
System.out.println(arr1[0]);//打印当前下表的值
System.out.println(arr2[2]);
System.out.println(arr3[1]);
System.out.println(arr4[4]);
System.out.println(Arrays.toString(arr1));//全部打印数组值
//char数组输出为内容
System.out.println(arr2);

注意:

  • 数组的引用同一时刻只能指向一个地址

3、数组的基本操作

3.1 遍历

 获取数组中的所有数据

  • 普通for循环：循环条件i作为数组的索引,确定索引变化的范围

  • 增强for循环–foreach

 for(数据类型 变量名:数组名|容器名){
        变量名 : 存放数据中的每一个数据,不是索引,是数据
    }

foreach更简单,而for循环的遍历更强大

int[] a1=new int[]{1,2,3,4,5};
        String[] arr6 =new String[]{"ab","cd","ef","eh"};

        //for循环遍历
        for (int i = 0; i < a1.length; i++) {
            System.out.println(a1[i]);
        }
        //增强foreach遍历
        for (String s:arr6) {
            System.out.println(s);
        }

3.1.1 练习

/*
 * 数组练习1
 */
public class ArrayTest03 {
    public static void main(String[] args) {
        int[] i1=new int[]{1,2,3,4,5};
        char [] c1 =new char[]{'a','b','c','d','e'};

        ArrayTest03 a = new ArrayTest03();
        //遍历
        a.test1(i1);
        //遍历char数组
        a.test2(c1);
        //最大值，最小值
        a.test3(i1);
        int [] i2=getMaxMin(i1);
        //倒序遍历
        a.test04(i1);

    }

    //A:遍历int类型的数组 依次输出每个数组元素
    public  void test1(int[] ints){
        for (int i = 0; i < ints.length; i++) {
            System.out.print(ints[i]+"  ");
        }
    }

    //B:遍历字符数组
    public void test2(char[] chars){
        for (char s:chars) {
            System.out.print(s+"  ");
        }
    }
    //C:最值:获取数组中的最大值和最小值
    public void test3(int[] ii){
        int max=0;
        int min=0;
        for (int i:ii) {
            if (max<=i)
                max=i;
            if (min>=i)
                min=i;
        }
        System.out.println("最大值："+max);
        System.out.println("最小值："+min);
    }
    public static int[] getMaxMin(int[] arr){
        //存储数组中的最大值
        int max = arr[0];
        int min = arr[0];

        for(int i:arr){
            if(i>max){
                max = i;
            }
            if(i<min){
                min = i;
            }
        }
        return new int[]{min,max};
    }

    //D:逆序:倒叙输出数组元素
    public void test04(int[] ints){
        for (int i = ints.length-1; i >=0 ; i--) {
            System.out.print(ints[i]+"  ");
        }
    }


}

3.2 数组比较

  java.util.Arrays 类是 JDK 提供的一个工具类，用来处理数组的各种方法，而且每个方法基本上都是静态方法，能直接通过类名Arrays调用。

其中 equals( [ ] , [ ] ) 方法则是用来比较两个数组内容是否相同

  注意：使用 equals()方法，调用的是Object中的方法。比较的是两个地址值

//比较数组值是否相等
        int[] a= new int[]{1,2,3};
        int[] b= new int[]{1,2,3};
        int[] c= new int[]{1,2,3,4};
        System.out.println(Arrays.equals(a,b));//true
        System.out.println(Arrays.equals(a,c));//false

3.3 元素拷贝

  Arrays工具类中提供了一系列 public static Object[] copyOf(Object[] original, int newLength) 的方法，可以拷贝原数组中指定长度的元素到一个新的数组并返回。

//拷贝
Arrays.copyOf(想拷贝数组,长度);
//还可以指定起始位置和截止位置。
System.arraycopy(类型[] 数组名, 开始下标, 结束下标);

String[] s = {"Mircosoft","IBM","Sun","Oracle","Apple"}; 
String[] sBak = new String[6]; 
System.arraycopy(s,0,sBak,0,s.length);

3.4 元素查找

  • 顺序查找。
  • 二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。
    • 二分查找法实质上是不断地将有序数据集进行对半分割，并检查每个分区的中间元素。

3.5 练习

ublic class ArrayTest05 {
    public static void main(String[] args) {
        int [] arr =new int[]{-127,-244,0,0,1,4,4,100,100,127,127};
        System.out.println(getSub(arr,0));;
        char[] chars=new char[]{'1','a','A','B','C'};
        System.out.println(change(chars));
    }

    /*1.数组元素查找(查找指定元素第一次在数组中出现的索引)
     * 若存在:返回这个元素的下标
     * 若不存在:返回-1
     */
    public static int getSub(int[] i,int a){
        for (int j = 0; j < i.length; j++) {
            if (a==i[j]){
                return j;
            }
        }
        return -1;
    }

//2.将一个存放了大写字母的数组转换成存放小写字母的数组返回
    public static char[] change(char[] arr){
        for(int i=0;i<=arr.length-1;i++){
        //如果字符不是A~Z之间的字符不变
            if(arr[i]>='A' && arr[i]<='Z'){
                arr[i]+=32;
            }
        }
         return arr;
}

}

4、数组异常

在使用数组时候，常遇到的一些异常：

  • 1.空指针异常
    NullPointerException
    数组 引用没有指向一个数组对象，指向为空null
  • 2.数组索引越界异常
    ArrayIndexOutOfBoundsException
    索引为负数 索引>=长度
int[] arr = {};
//arr  = null;//==NullPointerException==
System.out.println(arr.length);
System.out.println(arr[0]);//ArrayIndexOutOfBoundsException

5、一维数组练习

/*
    定义一个数组,存储班级所有的学生

    使用数组存储自定义引用数据类型的数据(自定义的类Student..)

        1.构建学生类javabean
        2.创建学生对象
        3.构建数组,存储学生对象
        4.遍历,操作..
 */
public class ArrayDemo06 {
    public static void main(String[] args) {
        //2.创建学生对象
        Student s1 = new Student(101,"张三",18,175);
        Student s2 = new Student(102,"李四",17,170);
        Student s3 = new Student(100,"王五",19,175.5);
        Student s4 = new Student(103,"赵六",20,175.5);
        Student s5 = new Student(104,"孙七",29,175);
        Student s6 = new Student(105,"周八",22,180);
        Student s7 = new Student(106,"吴九",23,180);

        //3.构建数组,存储学生对象
        Student[] arr = {s1,s2,s3,s4,s5,s6,s7};

        //遍历
        /*for(Student s:arr){
            System.out.println(s);
            System.out.println(s.getAge()+","+s.getName());
        }*/

        //身高数组
        //getHeight(arr);
        getStature(arr);
        //最高身高
        //getMaxHe(arr);

    }
    //统计:获取班级所有同学的升高,存在的身高值(去重),最终把出现的数值打印展示
        public static void getHeight(Student[] arr){
            //身高数组，默认值为0；
            double[] h=new double[10];
            int j=0;
            //循环Student数组，
            for (Student i: arr ) {
                boolean b=false;
                //循环对比身高
                for (int a = 0; a <= j; a++) {
                    //判断身高是否和数组有重复，有count+1
                    if (i.getHeight() == h[a]){ b=true;}
                }
                //判断count=0；等于0没有重复，输出
                if (b == false){ h[j++]=i.getHeight();}
            }
            //循环身高数组
            for(int z=0;z<=j;z++){
                //将默认值0不输出
                /*if (h[z] != 0.0) {
                    System.out.println(h[z]);
                }*/
            }
        }

        //方法2  找到身高最高的同学姓名(有几个打印|统计几个)
    public static void getStature(Student[] arr){
        double []height1=new double[7];
        double []height2=new double[7];
        int count=0;
        for (Student s: arr) {
            height1[count]=s.getHeight();
            count++;
        }
        one:for(int i=0;i<height1.length;i++){
            int jount=0;
            two:for(int j=0;j<i-1;j++){
                if(height1[i]==height1[j]){
                    jount++;
                    //continue one;//直接比较下一个数
                }
            }
            if ( jount==0 ) height2[i]=height1[i];
        }
        for (double d:height2){
            if(d!=0.0){
                System.out.println(d);
            }
        }
    }


    //2.找到身高最高的同学姓名(有几个打印|统计几个)
    public static void getMaxHe(Student[] arr){
        //添加默认最大值为数组0位数
        double max=arr[0].getHeight();
        //循环比较最大值
        for (Student i: arr ) {
            if (max<=i.getHeight()){
                max=i.getHeight();
            }
        }
        //循环输出跟最大值相等的Student数值信息。
        for (int a=0;a < arr.length;a++) {
            if (max==arr[a].getHeight()){
                System.out.println(arr[a]);
            }
        }
    }
}

6、二维数组

数组中放数组

6.1、声明

  • 数据类型[ ] [ ] 数组名; -->推荐
  • 数据类型 数组名[ ] [ ];
  • 数据类型[ ] 数组名[ ];
//声明
        int[][] ar ;

6.2 初始化

  • 动态初始化:

    • 在构建外层数组对象之后,直接构建内层的每一个小数组

      数据类型[][] 数组名 = new 数据类型[整数n外层数组长度][整数m内层每一个小数组长度];

    • 先构建外层数组对象,再构建内层的每一个小数组

       数据类型[][] 数组名 = new 数据类型[整数n外层数组长度][];

      ​ 构建内层的每一个小数组 : 就是一维数组的构建方式

  • 静态初始化:

    • 创建数组的同时赋值
    数据类型[][] 数组名 = new 数据类型[][]{{1,2,3},{4,5},{6}...};
    数据类型[][] 数组名 ={{1,2,3},{4,5},{6}...};

//动态
ar = new int[2][2];
//赋值
ar[0][0] = 14;

			//先构建外层数组对象,再构建内层的每一个小数组
        double[][] ar2 = new double[2][];
        //构建内层的每一个小数组
        ar2[0] = new double[3];
        ar2[1] = new double[]{1.1,2.2};

//静态初始化
int[][] ar3 = new int[][]{{1,2,3},{4,5},{6}};
//简化写法
int[][] ar4 = {{1,2,3},{1,2},{1}};
System.out.println(ar4);
//获取
System.out.println(ar4[0][0]);
System.out.println(ar4[0][1]);

6.3 二维数组遍历

  • 双重循环嵌套遍历

  • 普通for与foreach之间任意嵌套

public class ArrayDemo08 {
    public static void main(String[] args) {
        int[][] arr = {{1,2,3},{4,5},{6}};

        //foreach--foreach
        for(int[] i:arr){
            //i是每一个内层小数组
            for(int j:i){
                //j是内层小数组中的每一个数据值
                System.out.print(j+" ");
            }
        }

        System.out.println("\n-----------------------------------");
        //普通嵌套增强
        for(int i=0;i<=arr.length-1;i++){
            for(int j:arr[i]){
                System.out.print(j+" ");
            }
        }

        System.out.println("\n-----------------------------------");
        for (int[] a:arr) {
            for (int i = 0; i < a.length; i++) {
                System.out.print(a[i]+" ");
            }
        }
        System.out.println("\n-----------------------------------");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+" ");
            }
        }
    }
}
相关标签： Java java 编程语言

上一篇： An internal error occurred during: "Building workspace". Java heap space

下一篇： 让 IE6, 7和 8支持CSS3 css3ie6/ie7/ie8兼容

推荐阅读