Java数组

Java数组

1. Java如何创建一个数组

数组是一个固定长度,包含了相同类型数据的容器。

声明数组

int[] a; 声明了一个数组变量。

[] 表示该变量是一个数组

int 表示数组里的每一个元素都是整数

a 是变量名

但是,仅仅是这一句声明不会创建数组

也可以写成int a[]; 没有任何区别

public class HelloWorld{
    public static void main(String[] args) {
        // 声明一个数组
        int [] a;       
    }
}

创建数组

创建数字的时候,要指明数组的长度

new int[5]

引用概念:

​ 如果变量代表一个数组,比如a,我们把a叫做引用

​ 与基本类型不同

​ int c = 5; //这叫把5赋值给c

​ 声明一个引用 int[] a;

​ a = new int[5];

​ 让a这个引用,指向数组

public class HelloWorld{
    public static void main(String[] args) {
        //声明一个引用
        int[] a;
        //创建一个长度为5的数组,并且使用引用a指向该数组
        a = new int[5];

        int [] b = new int 5; // 声明的同时,指向一个数组
    }
}

访问数组

下标0表示数组里的第一个数

public class HelloWorld{
    public static void main(String[] args) {
        //声明一个引用
        int[] a;
        //创建一个长度为5的数组,并且使用引用a指向该数组
        a = new int[5];

        a[0] = 1;
        a[1] = 2;
        a[2] = 3;
        a[3] = 4;
        a[4] = 5;

    }
}

数组长度

.length属性 用于访问一个数组的长度

数组访问下标的范围是0~长度-1

一旦超过了这个范围,就是产生数组下标越界异常

public class HelloWorld{
    public static void main(String[] args) {
        //声明一个引用
        int[] a;
        //创建一个长度为5的数组,并且使用引用a指向该数组
        a = new int[5];

        //打印数组的长度
        System.out.println(a.length);
        a[0] = 1;
        a[1] = 2;
        a[2] = 3;
        a[3] = 4;
        a[4] = 5;
        a[5] = 10;  //超出了范围
    }
}

小练习

首先创建一个长度是5的数组

然后给数组的每一位赋予随机整数

通过for循环遍历数组,找出最小值

0~100的随机整数的获取方法:

(int)(Math.random() * 100)

Math.random()会产生0~1之间的随机浮点数,然后*100,然后强转为整型

public class HelloWorld{
    public static void main(String[] args) {

        int mini = 100;
        int [] a = new int[5];
        a[0] = (int)(Math.random() * 100);
        a[1] = (int)(Math.random() * 100);
        a[2] = (int)(Math.random() * 100);
        a[3] = (int)(Math.random() * 100);
        a[4] = (int)(Math.random() * 100);

        System.out.println("本数组的值为:");
        for (int i = 0; i<a.length;i++)
            System.out.println(a[i]);
        System.out.println("本例的目的是找到最小的值");

        //mini  = 100
        //如果a[i] <mini
        // mini = a[i]
        for(int i = 0;i<a.length;i++) {
            if(a[i] < mini) {
                mini = a[i];
            }
        }
        System.out.println("最小值"+mini);   

    }
}

2. Java如何初始化数组

空间分配和赋值分步进行

    public static void main(String[] args) {
        int[] a = new int[5]; //分配了长度是5的数组,但是没有赋值

        //没有赋值,那么就会使用默认值
        //作为int类型的数组,默认值是0
        System.out.println(a[0]);

        //进行赋值

        a[0] = 100;
        a[1] = 101;
        a[2] = 103;
        a[3] = 120;
        a[4] = 140;
    }
}

分配空间,同时赋值

public class HelloWorld {
    public static void main(String[] args) {
        //写法一: 分配空间同时赋值
        int[] a = new int[]{100,102,444,836,3236};

        //写法二: 省略了new int[],效果一样
        int[] b = {100,102,444,836,3236};

        //写法三:同时分配空间,和指定内容
        //在这个例子里,长度是3,内容是5个,产生矛盾了
        //所以如果指定了数组的内容,就不能同时设置数组的长度
        int[] c = new int[3]{100,102,444,836,3236};

    }
}

小练习(数组反转)

首先创建一个长度是5的数组,并填充随机数

使用for循环,或者while循环,对这个数组实现反转效果

public class HelloWorld{
    public static void main(String[] args) {
        int [] b = new int[5];
        int [] a = new int[5];
        a[0] = (int)(Math.random() * 100);
        a[1] = (int)(Math.random() * 100);
        a[2] = (int)(Math.random() * 100);
        a[3] = (int)(Math.random() * 100);
        a[4] = (int)(Math.random() * 100);

        System.out.println("本数组的值为:");
        for (int i = 0; i<a.length;i++)
            System.out.println(a[i]);

        for (int j = 0;j<5;j++)
            b[j] = a[4-j];

        System.out.println("反转之后的数组为");
        for (int i = 0; i<b.length;i++)
            System.out.println(b[i]);
    }
}

3. Java数组选择法,冒泡法排序

选择法排序

选择法排序的思路:

​ 把第一位和其他所有的进行比较,如果比第一位小,就换到第一个位置来

​ 比较完之后,第一位就是最小的

​ 然后再把第二位和剩余所有位比较,如果比第二位小,就换到第二位置来

​ 比较完之后,第二位就是第二小的

​ 。。。。。。

public class HelloWorld{
    public static void main(String[] args) {
        //定义一个数组
        int a [] = new int[]{18,53,93,13,44};
        //将数组打印出来
        for(int i  = 0;i<a.length;i++)
            System.out.println(a[i]+ " ");
        System.out.println(" ");

        //选择排序法
        //第一步
        for(int i = 1; i<a.length;i++) {
            if(a[i] < a[0]) {
                int temp = a[0];
                a[0] = a[i];
                a[i] = temp;
            }
        }
        // 把内容打印出来。可以发现最小的到了最前面
        for(int i  = 0;i<a.length;i++)
            System.out.println(a[i]+ " ");
        System.out.println(" ");

        //第二步
        for(int i = 2; i<a.length;i++) {
            if(a[i] < a[1]) {
                int temp = a[1];
                a[1] = a[i];
                a[i] = temp;
            }
        }
        // 把内容打印出来。可以发现最小的到了最前面
        for(int i  = 0;i<a.length;i++)
            System.out.println(a[i]+ " ");
        System.out.println(" ");

        //可以发现一个规律
        //移动的位置从0开始,逐渐增加
        //所以可以在外面套一层循环

        for(int j = 0; j<a.length-1;j++) {
            for(int i = j+1; i<a.length;i++) {
                if(a[i] < a[j]) {
                    int temp = a[j];
                    a[j] = a[i];
                    a[i] = temp;
                }
            }
        }
        // 把内容打印出来。可以发现最小的到了最前面
        for(int i  = 0;i<a.length;i++)
            System.out.println(a[i]+ " ");
        System.out.println(" ");

    }
}

冒泡排序法

冒泡法排序的思路:

​ 第一步:从第一位开始,把相邻两位进行比较

​ 如果发现前面的比后面的大,就把大的数据交换在后面,循环比较完毕后,最后一位就是最大的

​ 第二部:再来一次,但是不用比较最后一位了

​ 。。。。。。

public class HelloWorld_1{
    public static void main(String[] args) {
        int a[] = new int[] {18,53,93,13,44};
        //排序之前,先把数组中的内容打印出来
        for (int i = 0;i < a.length;i++)
            System.out.println(a[i] + " ");
        System.out.println(" ");

        //冒泡排序法
        //第一步
        for(int i = 0;i<a.length-1 ;i++) {
            if(a[i]>a[i+1]) {
                int temp = a[i];
                a[i] = a[i+1];
                a[i+1] = temp;
            }
        }
        //打印出来,可以发现最大的,已经在最后了
        for (int i = 0;i < a.length;i++)
            System.out.println(a[i] + " ");
        System.out.println(" ");

        //第二步
        for (int i = 0;i<a.length-2;i++) {
            if(a[i]> a[i+1]) {
                int temp = a[i];
                a[i] = a[i+1];
                a[i+1] = temp;
            }
        }
        //打印出来,可以发现,后两位已经排好了
        for (int i = 0;i < a.length;i++)
            System.out.println(a[i] + " ");
        System.out.println(" ");

        //发现了一个规律,后界在收缩,所以可以在外面套一层循环
        for(int j = 0;j<a.length;j++) {
            for(int i = 0;i<a.length-1-j ;i++) {
                if(a[i]>a[i+1]) {
                    int temp = a[i];
                    a[i] = a[i+1];
                    a[i+1] = temp;
                }
            }
        }
        //打印出来
        for (int i = 0;i < a.length;i++)
            System.out.println(a[i] + " ");
        System.out.println(" ");
    }
}

小练习

长度为5的数组,填充随机数,用选择法正向排序,然后用冒泡法倒序排序

public class HelloWorld_2{
    public static void main(String[] args) {
        int [] a = new int[5];
        //向空数组中填充随机数
        for(int i = 0;i<5;i++) {
            a[i] = (int)(Math.random()* 100);
        }

        //打印出来
        System.out.println("未排序的随机数数组:");
        for(int i = 0;i<5;i++) {
            System.out.println(a[i]+ " ");
        }
        System.out.println(" ");

        //使用选择法正向排序
        for(int j = 0; j< a.length-1;j++) {
            for (int i = j+1; i< a.length;i++) {
                if (a[j] > a[i]) {
                    int temp = a[j];
                    a[j] = a[i];
                    a[i] = temp;
                }
            }
        }
        //打印出来
        System.out.println("选择法排序:");
        for(int i = 0;i<5;i++) {
            System.out.println(a[i]+ " ");
        }
        System.out.println(" ");

        //使用冒泡法倒序排序
        for(int j = 0;j < a.length;j++) {
            for (int i  = 0; i <a.length-j-1; i++) {
                if(a[i]>a[i+1]) {
                    int temp = a[i];
                    a[i] = a[i+1];
                    a[i+1] = temp;
                }
            }
        }
        //打印出来
        System.out.println("冒泡法排序:");
        for(int i = 0;i<5;i++) {
            System.out.println(a[i]+ " ");
        }
        System.out.println(" ");

    }
}

4. Java中如何使用增强for循环

增强型for循环在遍历一个数组的时候会更加便捷

增强型for循环

注意:增强型for循环只能用来取值,不能用来修改数组里的值

public class HelloWorld_3{
    public static void main(String[] args) {
        int values[] = new int[] {18,62,68,65,9};
        //常规遍历
        for(int i = 0;i< values.length;i++) {
            int each = values[i];
            System.out.println(each);
        }

        //增强型for循环遍历
        for(int each : values) {
            System.out.println(each);
        }
    }
}

小练习(用增强型for循环找出最大的那个数)

public class HelloWorld_4{
    public static void main(String[] args){
        int a[] = new int[]{18,62,68,65,9};
        int c = a[0];
        for(int b:a){
            System.out.println(b);
            if(b>c){
                c = b;
            }
        }
        System.out.println("最大值"+c);
    }
}

5.Java如何复制数组

数组的长度是不可变的,一旦分配好空间,是多长就多长,不能增加也不能减少。

复制数组

把一个数组的值,复制到另一个数组中

System.arraycopy(src,srcPos,dest,destPos,length)

src 源数组

srcPos 从源数组复制数据的起始位置

dest 目标数组

destPos 复制到目标数组的起始位置

length 复制的长度

public class HelloWorld {
    public static void main(String[] args) {
        int a [] = new int[]{18,62,68,82,65,9};

        int b[] = new int[3];//分配了长度是3的空间,但是没有赋值

        //通过数组赋值把,a数组的前3位赋值到b数组

        //方法一: for循环

        for (int i = 0; i < b.length; i++) {
            b[i] = a[i];
        }

        //方法二: System.arraycopy(src, srcPos, dest, destPos, length)
        //src: 源数组
        //srcPos: 从源数组复制数据的起始位置
        //dest: 目标数组
        //destPos: 复制到目标数组的启始位置
        //length: 复制的长度       
        System.arraycopy(a, 0, b, 0, 3);

        //把内容打印出来
        for (int i = 0; i < b.length; i++) {
            System.out.print(b[i] + " ");
        }

    }
}

小练习(合并两个数组)

暂无评论

发送评论 编辑评论


				
上一篇
下一篇