文章目录

• • • 十六.数组的使用
    • • 数组的赋值机制
      • 一维数组的JVM内存布局
      • 冒泡排序
      • 查找
      • 二维数组
      • 二维数组的JVM内存布局
      • 二维数组的使用细节

创新互联服务项目包括夏津网站建设、夏津网站制作、夏津网页制作以及夏津网络营销策划等。多年来，我们专注于互联网行业，利用自身积累的技术优势、行业经验、深度合作伙伴关系等，向广大中小型企业、政府机构等提供互联网行业的解决方案，夏津网站推广取得了明显的社会效益与经济效益。目前，我们服务的客户以成都为中心已经辐射到夏津省份的部分城市，未来相信会继续扩大服务区域并继续获得客户的支持与信任！十六.数组的使用

• 数组是多个相同类型数据的组合，实现对这些数据的统一管理。

• 数组中的元素可以是任意数据类型，包括基本类型和引用类型，但是不能混合用

• 数组创建后，如果没有进行扶着，有默认值。

  byte 0，short 0，int 0，long 0，float 0 ，double 0，char \u0000，boolean false，String null。

• 使用数组的步骤：使用数组并开辟空间，给数组的各个元素进行复制，使用数组

• 数组的下标从0开始的

• 数组的下标必须在指定范围内使用，否则就会数组越界。

• 数组属于引用类型，数组数据的对象是object。

import java.util.Scanner;

public class array {public static void main(String[] args) {//创建一个char类型的26个元素的数组，分别放置'A'-'Z'.使用for循环访问所有元素并打印出来。
        char[] chars = new char[26];
        for (int i = 0; i< chars.length; i++ ) {chars[i] = (char)('A' + i);//这里由于'A' + i是int型，需要强制转换
        }
        System.out.println("chars数组如下：");
        for (int i = 0 ; i< chars.length; i++) {System.out.print(chars[i] + "  ");
        }
    }
}

public class array02 {public static void main(String[] args) {//请求出一个数组int[]的大值{4，-1，9，10，23},并得到相应的下标，并求出其平均值。
        int[] arrays = {4, -1, 9, 10, 23};
        int max = arrays[0];
        int maxindex = 0;
        int sum = 4;
        double avg = 0;

        for (int i = 1; i< arrays.length; i++ ) {if (arrays[i] >max) {max = arrays[i];
                maxindex = i;
            }
            sum += arrays[i];
        }
        avg = sum / arrays.length;
        System.out.println("该数组的大值为：" + max);
        System.out.println("其对应的下标为：" + maxindex);
        System.out.println("其平均值为：" + avg);

    }
}

数组的赋值机制

1. 基本数据类型赋值，这个值就是具体的数据，而且是互不影响的。
2. 数组在默认的情况下是引用传递的，赋的值是地址。

int[] arr1 = {1,2,3};
int[] arr2 = arr1;
arr2[0] = 10;
//赋值方式是引用赋值，arr2的变换会影响到arr1.
System.out.println("arr1的元素为：");
for (int i = 1; i< arrays.length; i++ ) {System.out.println(arr1[i]);
}

一维数组的JVM内存布局

​ 值传递 / 值拷贝和引用传递 / 地址拷贝的区别：

​ 值传递的时候相当于值拷贝，将原先的数值拷贝的一份，与之前的数据互不影响。

​ 数组指向的是一个地址，引用传递的时候指向的一个地址，在传递的时候只是将地址复制了一份。

​

int[] arr1 = {10.20.30};
int[] arr2 = new int[arr1.length];//arr2重新开辟了新的空间，与之前的地址互不影响

public class array03 {public static void main(String[] args) {//数组交换
        int[] arrs = {11, 22, 33, 44, 55, 66};
        int a = 0;
        int len = arrs.length;
        for (int i = 0; i< len / 2; i++) {a = arrs[len - i - 1];
            arrs[len - i - 1] = arrs[i];
            arrs[i] = a;
        }
        System.out.println("数组倒序排列后的结果如下：");
        for (int i = 0; i< arrs.length; i++) {System.out.print(arrs[i] + "  ");
        }
    }
}

public class array04 {public static void main(String[] args) {//数组的扩容
        int[] arr = {1, 2, 3};
        int[] arrNew = new int[arr.length + 1]; //定义一个新数组
        for (int  i = 0; i< arr.length ; i++ ) {arrNew[i] = arr[i];
        }
        arrNew[arrNew.length - 1] = 4;
        arr = arrNew; 
        System.out.println("数组扩容后的结果如下：");
        for (int i = 0; i< arr.length; i++) {System.out.print(arr[i] + " ");
        }
    }
}

import java.util.Scanner;

public class array05 {public static void main(String[] args) {//动态数组的扩容,每次在最后添加一个元素
        Scanner lll = new Scanner(System.in);

        int[] arr = {1, 2, 3};
        do {int[] arrNew = new int[arr.length + 1]; //定义一个新数组
            for (int  i = 0; i< arr.length ; i++ ) {arrNew[i] = arr[i];
            }

            System.out.println("请输入您要添加的元素：");
            int add1 = lll.nextInt();

            arrNew[arrNew.length - 1] = add1;
            arr = arrNew;

            System.out.println("数组扩容后的结果如下：");
            for (int i = 0; i< arr.length; i++) {System.out.print(arr[i] + " ");
            }

            System.out.println("");
            System.out.println("您是否还要继续添加(y/n):");
            char add2 = lll.next().charAt(0);

            if ( add2 == 'n') {break;
            } else if (add2 == 'y') {continue;
            } else {System.out.println("您输入的语法错误！！！");
                break;
            }

        } while (true);

        System.out.println("程序结束");
    }
}

import java.util.Scanner;

public class array06 {public static void main(String[] args) {//数组的动态缩减
        //有一个数组{1，2，3，4，5}，可以将该数组进行缩减，提示用户能否继续进行缩减，每次缩减最后的元素，当只剩下最后的一个元素，提示，不能在进行缩减，
        Scanner lll = new Scanner(System.in);

        int[] arr = {1, 2, 3, 4, 5};

        System.out.println("您最初的数组是{1，2，3，4，5}");

        do {System.out.println("您是否要继续缩减(y/n):");

            char add2 = lll.next().charAt(0);

            if ( add2 == 'n') {break;
            } else if (add2 == 'y') {if (arr.length == 1) {System.out.println("数组长度达到最小值，不能再进行缩减！！！");
                    break;
                }

                int[] arrNew = new int[arr.length - 1]; //定义一个新数组

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

                arr = arrNew;

                System.out.println("数组缩减后的结果如下：");

                for (int i = 0; i< arr.length; i++) {System.out.print(arr[i] + " ");
                }

                System.out.println("");

            } else {System.out.println("您输入的语法错误！！！");
                break;
            }

        } while (true);

        System.out.println("程序结束");
    }
}

冒泡排序

​ 原理：通俗的来讲就是两个两个重复多轮的进行比较，每执行一轮排序就能进行得到一个结果数。

​ 特点：

1. 每执行一轮排序就可以确定一个数的位置，比如第一轮排序确定大的数，第二轮排序确定第二大的数。
2. 当进行比较时，如果前面的数字大于后面的数字，就进行交换。
3. 每一轮比较的次数都在减少。有n个数据，第一轮排序需要排n-1，第二轮排序需要排n-2次。以此类推。

public class bubble_order {public static void main(String[] args) {//冒泡排序(从大到小排列)
        int[] arr = {24, 69, 80, 57, 13};
        int aaa = 0;
        for (int i = 0 ; i< arr.length - 1 ; i++ ) {for (int j = 0; j< arr.length - 1 - i ; j++) {if (arr[j] >arr[j + 1]) {aaa = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = aaa;
                }
            }
        }
        System.out.println("冒泡排序后的结果为：");
        for (int k = 0; k< arr.length; k++) {System.out.print(arr[k] + " ");
        }
    }
}

public class bubble_order2 {public static void main(String[] args) {//冒泡排序(从小到大排列)
        int[] arr = {24, 69, 80, 57, 13};
        int aaa = 0;
        for (int i = 0 ; i< arr.length - 1 ; i++ ) {for (int j = 0; j< arr.length - 1 - i ; j++) {if (arr[j]< arr[j + 1]) {//这里改个符号即可从小到大进行排列
                    aaa = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = aaa;
                }
            }
        }
        System.out.println("冒泡排序后的结果为：");
        for (int k = 0; k< arr.length; k++) {System.out.print(arr[k] + " ");
        }
    }
}

查找

import java.util.Scanner;

public class inquire {public static void main(String[] args) {//查找
        String[] names = {"狗子", "猴子", "胖子", "瘦子", "绝绝子"};
        Scanner lll = new Scanner(System.in);

        System.out.println("请输入您要查询的名字");
        String findName = lll.next();
        int tag = 0;//设置标记

        for (int i = 0; i< names.length ; i++ ) {if (findName.equals(names[i])) {System.out.println("恭喜找到：" + findName);
                System.out.println("下标为：" + i);

                tag = 1;
                break;
            }
        }
        if (tag == 0) {System.out.println("对不起，没有找到名字:" + findName);
        }

    }
}

二维数组

import java.util.Scanner;

public class array07 {public static void main(String[] args) {//输出一个二维数组
		int[][] arr = {	{1, 2, 3, 4, 5, 6},
			{1, 2, 3, 4, 5},
			{1, 2, 3, 4},
			{1, 2, 3}
		};
		System.out.println("输出的二维数组的结果如下：");
		for (int i = 0; i< arr.length ; i++) {	for (int  j = 0; j< arr[i].length ; j++) {		System.out.print(arr[i][j] + " ");
			}
			System.out.println(" ");
		}

	}
}

import java.util.Scanner;

public class array08 {public static void main(String[] args) {//二维数组的使用，动态数组赋值并输出
		Scanner lll = new Scanner(System.in);

		int arr[][];//声明二维数组
		arr = new int[2][3];//开辟数组空间，2行3列的二维数组。

		for (int i = 0; i< arr.length ; i++ ) {	System.out.println("现在输入数组的第" + i + "行数据");
			for (int j = 0; j< arr[i].length ; j++ ) {		System.out.println("输入第" + j + "列数据");
				int a = lll.nextInt();
				arr[i][j] = a;
			}
		}

		System.out.println("您输入的数组的结果如下：");

		for (int h = 0; h< arr.length ; h++ ) {	for (int k = 0; k< arr[h].length ; k++ ) {		System.out.print(arr[h][k] + " ");
			}
			System.out.println(" ");
		}
	}
}

import java.util.Scanner;

public class array09 {public static void main(String[] args) {//二维数组的使用，输出二维数组的第一行为1，第二行为两个2，第三行为3个3，以此类推。
		Scanner lll = new Scanner(System.in);

		System.out.println("您要输出几行：");
		int i = lll.nextInt();

		int[][] arr = new int[i][];

		for (int j = 0; j< arr.length ; j++ ) {	arr[j] = new int[j + 1];//第0层有1个空间，第1层有两个空间。

			for (int k = 0; k< arr[j].length ; k++ ) {		arr[j][k] = j + 1;//第一层的j等于0，所以要想每层都是对应层数的话，就需要进行加1
			}
		}

		System.out.println("您输入的数组的结果如下：");

		for (int m = 0; m< arr.length ; m++ ) {	for (int n = 0; n< arr[m].length ; n++ ) {		System.out.print(arr[m][n] + " ");
			}
			System.out.println(" ");
		}
	}
}

import java.util.Scanner;

public class array10 {public static void main(String[] args) {//二维数组的使用，动态数组赋值并输出
		Scanner lll = new Scanner(System.in);

		int arr[][];//声明二维数组
		arr = new int[3][3];//开辟数组空间，3行3列的二维数组

		for (int i = 0; i< arr.length ; i++ ) {	System.out.println("现在输入数组的第" + i + "行数据");
			for (int j = 0; j< arr[i].length ; j++ ) {		System.out.println("输入第" + j + "列数据");
				int a = lll.nextInt();
				arr[i][j] = a;
			}
		}

		int sum = 0;
		System.out.println("您输入的数组的结果如下：");

		for (int h = 0; h< arr.length ; h++ ) {	for (int k = 0; k< arr[h].length ; k++ ) {		System.out.print(arr[h][k] + " ");
				sum += arr[h][k];
			}
			System.out.println(" ");
		}
		System.out.println("您输入的数据总和为：" + sum);
	}
}

import java.util.Scanner;

public class YangHui {public static void main(String[] args) {//打印杨辉三角
		Scanner lll = new Scanner(System.in);

		System.out.println("您要输出几层杨辉三角：");

		int a = lll.nextInt();
		int[][] yanghui = new int[a][];
		for (int i = 0 ; i< yanghui.length ; i++) {	yanghui[i] = new int[i + 1]; //开辟新的空间。
			for (int j = 0 ; j< yanghui[i].length ; j++ ) {		if (j == 0 || j == yanghui[i].length - 1) {yanghui[i][j] = 1;
				} else {yanghui[i][j] = yanghui[i - 1][j - 1] + yanghui[i - 1][j];
				}
			}
		}
		System.out.println("输出结果如下：");
		for (int k = 0; k< yanghui.length ; k++ ) {	for (int l = 0 ; l< yanghui[k].length ; l++) {		System.out.print(yanghui[k][l] + " ");
			}
			System.out.println(" ");
		}
	}
}

import java.util.Scanner;

public class array11 {public static void main(String[] args) {//已知有一个升序的数组，要求插入一个元素，该数组的顺序依然是升序的，比如{10，12，45，90}，添加23后，数组为{10，12，23，45，90}
		Scanner lll = new Scanner(System.in);

		System.out.println("请先输入原始数组有几个数字（输入数字即可）：");
		int a = lll.nextInt();
		int[] arr = new int[a];
		int pt = 0;

		for (int i = 0 ; i< arr.length ; i++ ) {	System.out.println("请输入第" + (i + 1) + "个数");
			arr[i] = lll.nextInt();
		}

		System.out.println("您输出数组的结果如下：");

		for (int j = 0; j< arr.length ; j++ ) {	System.out.print(arr[j] + " ");
		}
		System.out.println(" ");
		//这里如果要对初始化的数组进行怕排序，可以使用冒泡排序进行。
		System.out.println("请输入您要插入的元素");

		int insert_element = lll.nextInt();
		int index = 0;

		for (int m = 0; m< arr.length; m++ ) {	if (insert_element< arr[m]) {		index = m;
				break;
			}else{		index = arr.length;
			}
		}

		int[] b = new int[arr.length + 1];
		for (int n = 0; n< b.length ; n++) {	if (n == index) {		b[n] = insert_element;
			} else if (n >index) {		b[n] = arr[n - 1];
			} else if (n< index) {		b[n] = arr[n];
			}
		}

		for (int k = 0; k< b.length ; k++) {	System.out.print(b[k] + " ");
		}

	}
}

public class array12 {public static void main(String[] args) {//随机生成10个整数（1-100）,保存到数组，并倒序打印以及求平均值，求大值和最小值的下标，并查找里面是否含有8.
		int[] arr = new int[10];

		for (int i = 0; i< arr.length ; i++) {	arr[i] = (int)(Math.random() * 100) + 1;
		}

		int sum = 0;
		int tag = 0;

		System.out.println("数组的正序输出如下：");
		for (int m = 0; m< arr.length ; m++ ) {	System.out.print(arr[m] + "\t");
		}
		System.out.println(" ");
		
		System.out.println("数组的倒序输出如下：");
		for (int j = arr.length - 1; j >= 0  ; j--) {	if (arr[j] == 8) {		tag = 1;//若含有8的话，则置为1；
			}
			sum += arr[j];
			System.out.print(arr[j] + "\t");//"\t"相当与空4个空格，一个tab键。
		}
		System.out.println(" ");

		System.out.println("平均值为：" + (int)(sum / arr.length));

		int max = arr[0];
		int min = arr[0];
		int max_sub = 0;//大值的下标
		int min_sub = 0;//最小值的下标

		for (int k = 0; k< arr.length ; k++) {	if (arr[k] >max) {		max_sub = k;
				max = arr[k];
			}
			if (arr[k]< min) {		min_sub = k;
				min = arr[k];
			}
		}

		if (tag == 1) {	System.out.println("是否含有8：" + "True");
		} else {	System.out.println("是否含有8：" + "False");
		}

		System.out.println("大值下标为：" + max_sub);
		System.out.println("最小值下标为：" + min_sub);
	}
}

二维数组的JVM内存布局

二维数组的使用细节

一维数组的声明方式有：int[ ] x 或者 int x[ ];
二维数组的声明方式有：int[][] y 或者int[] y[] 或者 int y[][]
二维数组实际上是由多个一维数组组成的，它的每个一维数组的长度可以相同也可以不相同。
比如：arr[][] = {{1,2},{1,2,3,4}}

布尔类型的数值未赋值之前默认为false。

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧

网站题目：（四）java中数组的使用-创新互联
URL链接：http://njwzjz.com/article/ceehop.html