JavaSE——基础知识回顾07之数组

文章目录

今天是回顾的第07天，今天的主要任务是完成对数组的认识与使用，从一维数组开始到一维数组的遍历查找以及后面的要学到的二维数组部分

---

---

前言

以后的Java学习难度将会慢慢变大，我希望自己能够矢志不移地战斗下去，望有缘人看到这篇文章后能够保持自己的初心，绝对不要害怕与后退。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、一维数组知识点

概念：一组数据的容器（数组可以存放多个数据）
知识点：1、数组是引用数据类型
2、数组中的数据又叫做元素
3、每个元素都有编号叫作 下标/索引（index）
4、下标从 0 开始，最后一个元素的下标可以用（数组.length-1）表示
5、数组初始化后，会在内存中开辟一连串的连续空间
6、数组一旦初始化后长度不可以改变（数组没有扩容和删除）
7、数组的操作：添加、修改、查询、删除
数组的初始化：
静态初始化：数据由程序员指定，长度由系统分配
动态初始化：长度由程序员指定，数据由系统操作（实际上还是操作者在干的事）

（1）、如何创建一个数组：

//语法格式：   数据类型[]  数组名字 =  new 数据类型[];
public static void main(String [] args){
		//1、静态初始化1
		String [] names=new String[]{"张三","李四","王五","陈六","赵七","雍仲"}
		//2、访问元素（从下标为0开始访问，最后一个元素我们用长度-1即：names.length-1来表示）
		System.out.println(names[0]);//张三,获取第一个元素
		System.out.println(names[names.length-1]);//雍仲，获取数组的最后一个元素
		//3、修改数组的元素
		//获取目标元素的下标 数组名[index]=新的元素;
		names[0]="大帅";
		System.out.println("names[0]");//大帅
		
}

数组的创建不是很难，这是一维数组的创建方式，后期会给大家介绍一下二维数组的介绍方式

（2）数组的遍历

遍历方法：
1、若需要使用到下标【idnex】我们就使用 for循环 （二维数组的时候我们就用for循环嵌套）
2、若不需要使用到下标【index】， 我们就使用 增强for循环------->
foreach（数组类型 接纳容器：遍历的数组对象 ）{
System.out.println(接纳容器);
}

//数组的遍历
//创建一个数组对象
public static void main(String[] args){
         //创建一个数组对象 num
         int [] num=new int[]{1,2,3,4,5,6};




         //1、使用for循环遍历（需要使用到下标index）
         for(int i=0;i<=num.length;i++){
               System.out.println(num[i]);//1,2,3,4,5,6
         }




         //2、使用增强for循环来遍历(需要使用到index)
         for(int i: num){
            System.out.println(i);//1,2,3,4,5,6
         }
         

}

（3）数组的查找（简单了解就行）

/**
		知识点：数组的查找 - 了解
		
		1.顺序查找：从头到尾遍历（即需要先对数组进行）
			for(int i = 0;i<is.length;i++){
				if(is[i] == num){
					System.out.println("查找到了");
				}
			}
		
		2.二分法查找
			前提：先排序通过中间值来寻找查询目标
		
	*/
	public static void main(String[] args){
	      int [] nums=new int[]{39,77,27,20,45,60};
	      int num=7;
	      //排序
	      Arrays.sort(nums);//需要先导入 import java.util.Arrays;
	      int start=0;
	      int end=is.length-1;
	      while(start<=end){
	            int mid=(start+end)/2;
	            if(num>is[mid]){
	                     start=mid+1;
	            }else if(num<is[mid]){
	            		end=mid-1;
				}else{
				  System.out.println("查找到了");
				  break;
				}
	      }
	}

（4）数组的复制

public class Test03{
	
	/**
		知识点：数组的复制1
		
		缺点：修改源数组，新数组的数据也随之改变
	*/
	public static void main(String[] args){
		
		//源数组
		String[] names = {"张三","李四","王五","陈六"};
		
		//新数组
		String[] newNames = names;
		
		//修改源数组
		names[0] = "王麻子";
		
		//遍历新数组
		for(String name : newNames){
			System.out.println(name);
		}
	}
}

//数组的复制02
//应用思想：通过遍历的方式将原数组中的元素赋值给新数组
//创建原数组
String[] names={"张三","李四","王五","王八"};
//创建新数组
String[] newNames=new String[names.length];
for(int i=0;i<names.length;i++){
      newNames[i]=names[i];
}
//遍历新数组
for(String name: newNames){
	System.out.println(name);
}

（5）数组的“扩容”

严格的说法来说 数组并不具备扩容的说法，这里的扩容是通过创建新数组使得新数组的长度发生了改变然后将原数组中的元素进行迁移Copy，仍然采用for循环遍历来进行迁移

public class Test05 {
	public static void main(String[] args) {
		//数组的扩容（改变长度）
		int [] num=new int [] {1,2,3,4,5,6,7,8,9};
		System.out.println(num.length);//9  新数组的长度
		//定义一个新数组
		int [] nums=new int[num.length*2];
		System.out.println(nums.length);//18  新数组的长度

         for(int i=0;i<=num.length-1;i++){
                nums[i]=num[i];
		}
		//将新数组的地址赋值给原数组
		num=nums;
		for(int n:num){
          System.out.println(n);
			}
	}
	

（6）数组的删除

public class Test06{
	
	/**
		知识点：数组的删除1
		
		缺点：数组原本是存放数据的，删除元素后，数组长度变短
		
		作业：画内存图
	*/
	public static void main(String[] args){
		
		//源数组
		String[] names = {"张三","李四","王五","陈六"};
		
		//新数组
		String[] newNames = new String[names.length-1];
		
		//将源数组的数据迁移到新数组中，要删除的元素(张三)除外
		int index = 0;//新数组的下标
		for(String name:names){
			if(!name.equals("张三")){
				newNames[index] = name;
				index++;
			}
		}
		
		//将新数组的地址赋值给源数组，重点所在
		names = newNames;
		
		//遍历源数组
		for(String name:names){
			System.out.println(name);
		}
	}
}

public class Test07{
	
	/**
		知识点：数组的删除2
		
	*/
	public static void main(String[] args){
		
		//源数组
		String[] names = {"张三","李四","王五","陈六"};
		
		//数据的迁移
		for(int i = 1;i<names.length-1;i++){
			names[i] = names[i+1];
		}
		names[names.length-1] = null;
		
		//遍历源数组
		for(String name:names){
			System.out.println(name);
		}
	}
}

（7）数组的参数值（可变长参数）

/**
 知识点：数组的参数和返回值

 需求：设计一个方法，传入数组，返回最大值和最小值
 */

public class Test02 {
    public static void main(String[] args) {
        int [] num=new int[]{1,2,3,4,5,6,7,8,9};
        int [] newArr=method(num);
        System.out.println("最大值为：" + newArr[0]);
        System.out.println("最小值为：" + newArr[1]);

    }
    public static int[] method(int[] arr){
        int max=arr[0];
        int min=arr[0];
        for (int i=0;i<=arr.length-1;i++){
            if (max<arr[i]){
                max=arr[i];
            }
            if (min>arr[i]){
                min=arr[i];
            }
        }
        return new int[]{max,min};
    }
}

（8）数组的排序

//冒泡法排序
//即相邻的两个数字作比较，大的往后移动
public class Test02 {
    public static void main(String[] args) {
        int[] nums = {5, 4, 3, 1, 2};//定义一个实验对象


        //进行冒泡排序法的操作，操作实质是将两个相邻的数字进行比较，其比较的次数是长度-1
        for (int k=0;k<nums.length-1;k++){//控制整个循环结构需要比较的次数
            for (int i = 0; i < nums.length-1-k; i++) {//循环次数为数组的长度-1即可，-k是为了优化代码，不影响结果
                // 因为是两个为一组进行比较，这样可以避免下标越界的情况
                if (nums[i]>nums[i+1]) {
                    int temp=nums[i];
                    nums[i]=nums[i+1];
                    nums[i+1]=temp;
                }
            }
        }
        for (int j=0;j<nums.length;j++){
            System.out.print(nums[j]+"\t");
        }
    }
}

总结：本次任务中 重难点应该是在数组的扩容与删除中，其中的共同点就是需要创建新的数组来进行值的迁移，最容易被遗忘的一点就是 迁移完了 容易忘掉将新数组的地址值付给原数组 ，说白了 新数组就是个媒介打酱油的，最后披着原数组的包装充当了原数组

二维数组知识点

（1）二维数组的定义

/**
 * 初识二维数组，  高纬代表行 ，低纬代表列。
 */
public class Test01 {
    public static void main(String[] args) {
        /*准备部分，定义一个二维数组*/
        int[][] nums = new int[3][5];
        /*为二维数组注入值*/
        nums[0][0] = 10;
        nums[0][3] = 20;
        nums[1][0] = 30;
        nums[1][1] = 40;
        nums[2][2] = 50;
        nums[2][4] = 60;


        for (int i = 0; i < nums.length; i++) {//外层循环控制行数，此处的 nums.length是指 高维的长度，即行数
            for (int j = 0; j < nums[i].length; j++) {//内层循环控制循环体,即低纬
                System.out.print(nums[i][j]+"\t");
            }
            System.out.println();
        }
        //System.out.println(nums[0][1]);
    }
}

（2）项目实战（打印杨辉三角）

public class Test02 {
    public static void main(String[] args) {
        int rows = 5;
        int[][] YH = new int[rows][];
        //创建多个不同长度的二维数组
        for (int i = 0; i < rows; i++) {
            YH[i] = new int[i + 1];
        }
        //完成初始值的赋值（每行的首尾都是1）
        for (int i = 0; i < YH.length; i++) {
            YH[i][0] = 1;
            YH[i][i] = 1;
        }
        //计算
        for (int i = 2; i < YH.length; i++) {
            for (int j = 1; j < i; j++) {
                //当前位置的值=上一行的同列+上一行的前一个列
                YH[i][j] = YH[i - 1][j] + YH[i - 1][j - 1];
            }
        }
        //样式处理

        for (int i = 0; i < YH.length; i++) {
            for (int j = rows - 1; j > i; j--) {//满足四次
                System.out.print("\t");
            }
            for (int j = 0; j < YH[i].length; j++) {
                System.out.print("\t" + YH[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

（3）实战案例（五子棋项目）

import java.util.Scanner;

public class Test01 {
	
	public static void main(String[] args) {
		
		int length = 20;//棋盘长度
		String[][] goBang = new String[length][length];//棋盘的容器
		//棋盘符号
		String add = "╋";
		String black = "■";
		String white = "○";
		String[] nums = {"⒈","⒉","⒊","⒋","⒌","⒍","⒎","⒏","⒐","⒑","⒒","⒓","⒔","⒕","⒖","⒗","⒘","⒙","⒚","⒛"};
		
		//初始化棋盘数据
		for (int i = 0; i < goBang.length; i++) {
			for (int j = 0; j < goBang[i].length; j++) {
				if(j == length-1){
					goBang[i][j] = nums[i];
				}else if(i == length-1){
					goBang[i][j] = nums[j];
				}else{
					goBang[i][j] = add;
				}
			}
		}
		
		//打印棋盘
		for (String[] strings : goBang) {
			for (String string : strings) {
				System.out.print(string);
			}
			System.out.println();
		}
		
		Scanner scan = new Scanner(System.in);
		
		boolean flag = true;//true-黑子 false-白子
		while(true){
			System.out.println("请" + ((flag)?"黑":"白") + "子输入坐标：");
			int x = scan.nextInt()-1;
			int y = scan.nextInt()-1;
			
			//判断坐标是否超出棋盘范围
			if(x < 0 || x > length-2 || y < 0 || y > length-2){
				System.out.println("坐标超出棋盘范围，请重新输入...");
				continue;
			}
			
			//判断坐标上是否有棋子
			if(!goBang[x][y].equals(add)){
				System.out.println("坐标上有棋子，请重新输入...");
				continue;
			}
			
			//落子
			goBang[x][y] = (flag)?black:white;
			
			//置反
			flag = !flag;
			
			//打印棋盘
			for (String[] strings : goBang) {
				for (String string : strings) {
					System.out.print(string);
				}
				System.out.println();
			}
		}
	}
}

总结

：以上就是今天要讲的内容，本文仅仅简单介绍了数组的一些基本使用与创建和一些小细节问题