一维数组的初始化与遍历

曾经终败给现在 2022-05-25 09:06 189阅读 0赞

这里主要写一些一维数组的初始化操作与遍历方式，给初学者一些帮助，同时对自己也算是总结吧。

一维数组的初始化分为两种：1、基本类型数组的初始化；2、引用类型数组的初始化；

至于遍历方式也分两种：1、普通的for()\{\}循环；2、foreach循环；

先说，基本类型数组的初始化，在内部会用这两中遍历方式遍历数组：

package com.google.array.array01;
    
    /**
     * 基本类型数组：数组中的元素是基本类型的数据，这种数组就成为基本类型的数组：
     * 有8种：byte,short,int,long,float,double,char,boolean
     */
    public class BaseTypeArray {
    
        public static void main(String[] args){
    
            //先定义一个数组：arr[0]=1,arr[1]=8,arr[2]=4,arr[3]=3,arr[4]=25,arr[5]=47,arr[6]=45,
            int[] arr={1,8,4,3,25,47,45};
    
            //使用for循环遍历数组：1,8,4,3,25,47,45,
            circulation01(arr);
    
    
            //使用foreach循环遍历数组：
            circulation02(arr);
        }
    
    
        /**
         * 数组的定义:用两种方式
         * 这里使用int类型
         */
        public static void defineArray(){
            int[] arr;
            int arr02[];
        }
    
        /**
         * 数组的赋值：3种
         */
        public static void initArray(){
    
            //第一种赋值方式：
            int[] arr = new int[3];
            arr[0]=0;
            arr[1]=1;
            arr[2]=2;
    
            //第二种赋值方式：
            int[] arr02 = new int[]{0,1,2};
    
            //第三种赋值方式：
            int[] arr03={0,1,2};
        }
    
        /**
         * for循环遍历数组
         * @param arr
         */
        public static void circulation01(int[] arr){
    
            for(int i=0;i<arr.length;i++){
                System.out.print("arr["+i+"]="+arr[i]+",");
            }
        }
    
    
        /**
         * foreach遍历数组
         * @param arr
         */
        public static void circulation02(int[] arr){
    
            for(int a:arr){
                System.out.print(a+",");
            }
        }
    }

再说引用类型的数组，同样用for和foreach遍历：

先定义一个实体类：

package com.google.array.array02;
    
    public class Student {
    
        private String name;
        private int age;
    
    
    
        public Student() {
        }
        public Student(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;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

然后在对这个引用类型的实体类进行操作：

package com.google.array.array02;
    
    /**
     * 引用类型数组的引用：
     */
    public class RefTypeArray {
    
        public static void main(String[] args){
            /**
             *   student[0]=Student{name='张1', age=1}
                 name-0=张1
                 age-0=1
                 student[1]=Student{name='张2', age=2}
                 name-1=张2
                 age-1=2
                 student[2]=Student{name='张3', age=3}
                 name-2=张3
                 age-2=3
             */
            dynamicInit();
    
            /**
             *  Student{name='赵6', age=12}
                Student{name='赵7', age=15}
                Student{name='赵8', age=17}
             */
            staticInt();
        }
    
        /**
         * 动态初始化引用类型的数组：
         */
        public static void dynamicInit(){
    
            //创建学生对象：
            Student stu1=new Student("张1",1);
            Student stu2=new Student("张2",2);
            Student stu3=new Student("张3",3);
    
            //创建一个数组容器，尺寸为3，用来存放学生元素：
            Student[] student=new Student[3];
            student[0]=stu1;
            student[1]=stu2;
            student[2]=stu3;
    
            print1(student);
        }
    
        /**
         * 静态初始化数组：
         */
        public static void staticInt(){
    
            //第一种方式：
            Student[] student={new Student("赵6",12),new Student("赵7",15),new Student("赵8",17)};
    
            //第二种方式：有点麻烦
            /*Student stu1=new Student("赵6",12);
            Student stu2=new Student("赵7",15);
            Student stu3=new Student("赵8",17);
            Student[] student2={stu1,stu2,stu3};*/
    
            print2(student);
        }
    
        /**
         * 采用for循环：
         * @param student
         */
        public static void print1(Student[] student){
    
            for(int i=0;i<student.length;i++){
                System.out.println("student["+i+"]="+student[i]);
                System.out.println("name-"+i+"="+student[i].getName());
                System.out.println("age-"+i+"="+student[i].getAge());
            }
    
    
        }
    
        /**
         * 采用foreach循环：
         * @param student
         */
        public static void print2(Student[] student){
    
            for(Student stu:student){
                System.out.println(stu);
            }
        }
    
    
    }

至于内存分析，这里就不说了，只要记住，数组是一个引用，

对于基本类型，内部存放的是数值；

对于引用类型，内部存放的仍然是一个引用；