数组

麻花痒 · 2022-8-28 14:04:02

数组介绍：

可以存放同一类型的数据，包括基本数据类型和引用类型
数组也是一种数据类型，引用类型

数组的声明和创建：

动态初始化创建 --> 数据类型[] 数组名 = new 数据类型[大小]
静态初始创建 --> 数据类型[] 数组名 = {参数1，参数2,.........}
length获取数组长度 --> 数组名.length
[0],[1]通过下标赋值和获取 --> 赋值：数组名[0] = 1,获取：print(数组名)
1.  //静态初始化数组 　　 int[] max = {1,2,3,4}; //静态初始化数组
2. System.out.println(max.length);
3. System.out.println(max[0]+" "+max[1]);
4. //max = {9,8,6}; 数组一旦创建，大小是不可以被改变的
5.  //动态初始化数组
6. int[] scores = new int[10];//1.动态初始化一个大小为10的数组
7. scores[0] = 1; //2.通过下标给数组赋值
8. scores[1] = 2;
9. scores[2] = 3;
10. scores[3] = 4;
11. int sum = 0;
12. for (int i = 0; i < scores.length; i++) {
13. System.out.println(scores[i]);//3.数组中没有赋值的数默认为0
14. sum+= scores[i];//求数组中的和
15. }
16. System.out.println(sum);
18.  //通过声明数组数组
19. int[] nums;//声明一个数组
20. nums = new int[10]//设置数组大小
复制代码

数组赋值机制：　　

数组的小细节：

数组一旦创建，大小是不能被改变的

数组中的元素必须相同，不能出现混合类型

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

创建数组没有赋值，默认值是0

数组下标必须是指定内的，不然下标越界异常 ArrayIndexOutOfBoundsException

for-Each循环：

大多用来输出数组中的元素，因为无法操作下标

 int[] nums = {4,-1,9, 10,23};
 //for-Each循环，nums表示数组，num表示数组里的每一个元素
 for (int num : nums) {
 System.out.println(num);
 }
复制代码
反转数组：

思路：数组长度一共为5，那么代表下标4-0换，3-1换，一共循环2次

定义一共变量，暂时保存替换的数，当下标4和下标0换时，把其中一共下标的数保存到变量中，另一共下标的数替换到，被、保存下标数的位置

当替换完成，那么在把保存的数，替换到空下标位

 int[] nums = {4,-1,9, 10,23};
 int temp = 0; //暂时保存
 for (int i = 0; i < nums.length/2; i++) {
 temp = nums[nums.length - 1 -i ];//保存4下标
 nums[nums.length -1 -i] = nums[i];//把0下标给4下标
 nums[i] = temp;//0下标获取4下标
 }
 for (int num : nums) {
 System.out.println(num);
 }
复制代码
数组拷贝：

int[] num = {4,-1,9, 10,23};//被拷贝
 int[] nums = new int[num.length];//创建一共和被拷贝数组一样大小数组
 for (int i = 0; i < nums.length; i++) {
 nums[i] = num[i];//拷贝
 }
 nums[0] = 200;//改变nums的数，不会影响到num

 for (int i = 0; i < nums.length; i++) {
 System.out.println(nums[i]);
 }
复制代码
二维数组：

理解：文件夹中创建文件夹等于二维数组

文件夹中创建文件夹在创建文件夹等于三维数组 -- 可以一直嵌套

　　　　 int[][] nums = {{1,2},{3,4},{5,6}};//创建二维数组
 System.out.println(nums.length);//长度为3，因只是算一个一个大括号
 System.out.println(nums[0][0]);//获取第一个二维数组中，的第一个数组元素
 for (int i = 0; i < nums.length; i++) {//循环3次 0-1-2
 for (int j = 0; j < nums.length -1; j++) { //循环2次 0-1
 System.out.println(nums[i][j]);//获取二维数组所有元素
 }
 }
复制代码

Arrays[儿微史]工具类：

作用：用来操作数组，快捷方便只需要调用封装好的方法即可

Arrays.toString(nums) --> 输入数组所有元素

Arrays.sort(nums) ---> 升序排序

Arrays.fill(nums,2,5,0) ---> 数组填充

 double[] nums = {1.1,1.2,66,6,99.9};
 System.out.println(Arrays.toString(nums));//输出数组所有元素
 Arrays.sort(nums);//给数组排序
 System.out.println(Arrays.toString(nums));
 Arrays.fill(nums,0);//给数组填充，结果就是全部是0
 Arrays.fill(nums,2,4,0);//给数组填充2-4的下标
 System.out.println(Arrays.toString(nums));
复制代码

可以通过查看源代码，查看该工具类中有什么方法使用

　
冒泡排序(重点)：

冒泡排序 - 从小到大 - 从大到小的排序

思路：如：大-小，拿出一个元素，和元素+1比较，那么比较了所有就会得到最大的数，下一次在比较就可以省略该数，所有每次比较-1

优化：数组是顺序，就不进行比较，知道if返回是布尔型通过返回的类型，得知是否进入到if，false代表顺序，true代表进入if不是顺序，flase就跳出循环

//冒泡排序 - 从小到大 - 从大到小
 //优化：通过boolean类型变量来判断数组是否是顺序
 int[] ares = {1,2,3,4,5,6,7};
 int temp = 0;//暂时保存
 for (int i = 0; i < ares.length - 1; i++) {//循环4次,-1是因为长度是7，实际循环6次，从0开始所以-1
 boolean king = false; //没有交换位置为false
 for (int j = 0; j < ares.length - i - 1; j++) { //
 if(ares[j] > ares[j+1]){ //if条件不成立返回false
 System.out.println("参数是否交换");
 temp = ares[j]; //暂时保存
 ares[j] = ares[j+1];
 ares[j+1] = temp;
 king = true; //交换位置了为true,if判断返回的值是false和true，不满足条件肯定是false
 }
 }
 if(!king){
 System.out.println("参数代码");//输出此代码，代表没有交换
 break;
 }
 }
 System.out.println(Arrays.toString(ares));
复制代码
稀疏数组：

压缩信息记录有效信息，如图：把；获取有效值，并获取坐标就好

int[][] ares = new int[11][11]; // 列[9]---行[11]
 ares[1][2] = 1;
 ares[2][3] = 2;
 //1.输出数组
 for (int[] are: ares) {//11给元素
 for (int a : are) {//11个元素里面的元素
 System.out.print(a+"\t");//打印11个元素
 }
 System.out.println();
 }
 //2.转换为稀疏数组-就是获取有值的个数
 int num = 0;
 for (int i = 0; i < ares.length; i++) {
 for (int j = 0; j < ares.length; j++) {
 if(ares[i][j]!=0){
 num++;
 }
 }
 }
 System.out.println("有效值:"+num);
 //3.创建一个存放稀疏数组的，数组
 int[][] array2 = new int[num+1][3];
 array2[0][0] = 11;
 array2[0][1] = 11;
 array2[0][2] = num;
 //3.1.遍历数组,将非零的值放到稀疏数组
 //{{11111111...},{1111...},.....}
 int count = 0;//记录应该放到稀疏数组的第几行
 for (int i = 0; i < ares.length; i++) {//遍历的是每一个二维数组里面的一维数组
// System.out.println(i);//遍历11次
 for (int j = 0; j < ares[i].length; j++) {//ares[i].length;遍历的是一维数组里面的元素
 //获取有效元素
 if(ares[i][j]!=0){//判断了整个二维数组，不等于零的值
 ++count;//count变量是记录每增加一行数据，应该放到哪一列中
 array2[count][0] = i;
 System.out.println("::::"+count);
 array2[count][1] = j;
 array2[count][2] = ares[i][j];
 }
 }
 }
 //4.输出稀疏数组
 System.out.println("稀疏数组");
 for (int i = 0; i < array2.length; i++) {
 System.out.println(array2[i][0]+"\t"+
 array2[i][1]+"\t"+
 array2[i][2]+"\t");
 }
 //还原稀疏数组
 System.out.println("=====还原稀疏数组=====");
 //1.读取稀疏数组
 int[][] array3 = new int[array2[0][0]][array2[0][1]];//大小11,11
 //2.给其中元素还原它的值
 for (int i = 1; i < array2.length; i++) {//遍历稀疏数组
 array3[array2[i][0]][array2[i][1]] = array2[i][2];//给坐标，赋值操作，0是列坐标，1行坐标，2是值
 }
 //3.打印还原数组
 for (int[] are: array3) {//11给元素
 for (int a : are) {//11个元素里面的元素
 System.out.print(a+"\t");//打印11个元素
 }
 System.out.println();
 }
复制代码
案例应用：

 //保存26之母到数组
 //char是用unicode码，所有可以通过加1来实现字母的赋值
 char[] chars = new char[26];
 for (int i = 0; i < chars.length; i++) { //循环26次
 chars[i] = (char)('A'+i); //i是int类型使用要强转
 }
 for (int i = 0; i < chars.length; i++) {
 System.out.println(chars[i]);
 }
 //求出最大的数，得到下标
 int[] nums = {4,-1,9, 10,23};
 int max = nums[0]; //假设一个最大值
 int maxIndex= 0; //获取下标
 for (int i = 0; i < nums.length; i++) {
 if(max < nums[i]){
 max = nums[i];
 maxIndex = i;
 }
 }
 System.out.println(max);
 System.out.println(maxIndex);
复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

		自动登录	找回密码
密码			立即注册

数组

0 个回复

快速回复

楼主热帖

标签云