JAVA基础04-循环，数组以及排序算法

目录

循环语句

循环的控制语句

数组的使用

数组的知识点掌握

数组的声明

数组对象的创建

多维数组的定义和创建

数组的初始化以及内存分析

 内存分析总结

数组排序及其操作

冒泡排序

选择排序

练习（二分查找）

数组工具类的使用

---

循环语句

循环中具备哪些要素？初始化的变量、条件、循环执行体、迭代

while

先判断再执行

do while

不管条件是否成立都会执行一次 如果条件成立则继续执行

for

for(初始化;条件;迭代)

foreach

for(临时变量:数据源)

---

练习

阶乘

import java.util.Scanner;
 
public class Test1 {
 
	public static void main(String[] args) {
		// 通过Scanner 获取一个整数，然后使用while计算这个整数的阶乘
		// N的阶乘等于 N* (N-1) * (N-2) * ... * 1
		Scanner sc = new Scanner(System.in);
		// 获取一个数值
		int n = sc.nextInt();
		System.out.print(n);
		// 定义一个结果
		int result = n;
		// 循环进行乘积  5*4*3*2*1
		while(n>1) {
			//迭代
			n--;
			//求取乘积
			result = result*n;
		}
		//打印输出结果
		System.out.println("的阶乘结果为："+result);
	}
 
}

---

实现9*9的乘法表

 
public class Test2 {
 
	public static void main(String[] args) {
		// 9*9的乘法表
		//外循环：遍历9次--相当于打印每一行的乘法表
		for(int n=1;n<=9;n++) {
			//内循环：遍历n次--打印当前行的n个乘法表式
			for(int i=1;i<=n;i++) {
				//格式化输出
				System.out.printf("%d*%d=%d \t",i,n,(i*n));// 其中\t为转义字符，制表符~
			}
			//换行
			System.out.println();
		}
	}
 
}

---

循环的控制语句

break语句

结束、退出循环

public class ForController {
 
	public static void main(String[] args) {
		// 1、break语句
		//当i==5时，则结束循环，不再输出
		for (int i = 1; i <= 10; i++) {
			//
			if(i==5) {
				break;
			}
			//
			System.out.println(i);
		}	
	}
 
}

continue语句

忽略当前循环，继续下一个循环操作

//2、continue语句
		//当i==5时，则跳过当前循环，再继续下一次循环【忽略当前循环所剩下的操作】
		for (int i = 1; i <= 10; i++) {
			if(i==5) {
				continue;
			}
			System.out.println(i);
		}

return语句

结束方法，不再执行剩下的所有操作

 
        //3、return语句
        //当i==5时，则结束方法
        for (int i = 1; i <= 10; i++) {
            if(i==5) {
                return;
            }
        System.out.println(i);
        }

label标签语句

label标签是结合控制语句一起使用的

label语法格式： 标签名:

 
        //标签--标记label 应用在多重循环嵌套中的流程控制  语法格式为    标识符:
        outside:
 
        //当k==5时，结束整个多重循环
        for (int i = 1; i <= 10; i++) {
            System.out.println("i="+i);
            for (int k = 1; k <= 10; k++) {
                if(k==5) {
                    continue outside;
                }
                System.out.println(k);
            }
        }
        System.out.println("main方法结束了！");

---

练习

打印1-100，忽略3和5的倍数

水仙花

public class ForControllerTest {
	public static void main(String[] args) {
		//打印 1-100 之间的数，如果这个数是3或者5的倍数，就忽略掉
		for(int i=1;i<=100;i++) {
			if(i%3==0||i%5==0) {
				continue;
			}
			System.out.print(i+"\t");
		}
		System.out.println();
		//水仙花数定义：寻找所有的水仙花数
		for(int i=100;i<=999;i++) {
			//求取百十个的数值
			int bai = i/100;
			int shi = (i/10)%10;
			int ge = i%10;
			//计算并且判断是否满足条件
			if((bai*bai*bai+shi*shi*shi+ge*ge*ge)==i) {
				System.out.println(i);
			}
		}
	}
}

---

数组的使用

数组的知识点掌握

1、声明数组、创建数组对象、数组的数据访问【索引-内存】

2、遍历数组【for、foreach】

3、数组的内存存储原理

数组的声明

  int[] arr;//推荐使用这种方式
        int arrs[];

数组对象的创建

 
//2、如何创建数组对象[必须要指定数组的长度]【固定长度】
        //--静态形式：
        int[] arres = {1,2,3,4,5,6};
        //--动态形式
        int[] arres1 = new int[]{1,2,3,4,5,6};
        int[] arres2 = new int[6];
        //通过索引访问数组中的数据，注意是从0开始的
        System.out.println(arres[2]);

多维数组的定义和创建

多维数组就是一个数组中包含多个数组

创建数组对象会默认初始化 引用类型默认为null

索引代表的含义：new int[3][3]; 第一个索引表示的是多少个一维数组，第二个索引表示一维数组中有多少个数据

//多维数组的创建
int[][] arrays = {
				{1,2,3},{4,5,6},{7,8,9}
		};
		//		ArrayIndexOutOfBoundsException 数组的索引越界

注意数组越界异常：ArrayIndexOutofBoundsException

数组的遍历

		//1、普通的for
		for(int i=0;i<arres.length;i++) {//一维
			System.out.println(arres[i]);
		}
 
		//外循环遍历二维中的一维数组
		for(int i=0;i<arrays.length;i++) {//二维
			//内循环遍历一维数组中的数组
			for(int k=0;k<arrays[i].length;k++) {
				System.out.println(arrays[i][k]);
			}
		}
		
		//2、foreach
		for (int is : arres) {//一维 \用is遍历arres数组的每个数据
			System.out.println(is);
		}
		for (int[] is : arrays) {//二维
			for (int i : is) {
				System.out.println(i);
			}

数组的初始化以及内存分析

 

 内存分析总结

1、变量是在栈内存中定义的，里面存放的是数组的引用地址

2、数组是一个引用类型、数组是一个对象数据，存放在堆内存中的

3、一维数组：

【基本数据类型】：当前堆内存块中直接存放该数值

【引用类型】：当前堆内存块中存放是该引用类型的对象地址

4、多维数组：

当前堆内存块中存放是该子数组的对象引用地址

---

数组排序及其操作

冒泡排序

import java.util.Arrays;
 
public class ArrayDemo1 {
 
	public static void main(String[] args) {
		/*
		 * int[] arr = new int[6]; for (int i : arr) { System.out.println(i); }
		 */
		// 每次操作后，确定一位【冒一次泡】
        //重复地走访过要排序的元素列，依次比较两个相邻的元素
		int[] arr = { 5, 101, 978, 43, 45, 64, 1, 65 };
		// 没确定一位之后，下一次操作的比较次数减少一次
		// 具体要操作多少次？（n-1）；每次操作要比较多少轮?(n-i)
		for (int n = 0; n < arr.length - 1; n++) {// 0~6
			// 每次操作要比较(n-i)轮
			for (int i = 0; i < arr.length - n - 1; i++) {// 0~6
				// 当前面的大于后面的则需要交换
				if (arr[i] > arr[i + 1]) {
					int item = arr[i];
					arr[i] = arr[i + 1];
					arr[i + 1] = item;
				}
			}
		}
		//遍历输出
		for (int i : arr) {
			System.out.println(i);
		}
	}
 
}

---

选择排序

		//选择排序
		//方法一：将第一个与其后面所有数值进行比较，第二个也是如此
		for (int n = 0; n < arr.length - 1; n++) {// 0~6  起始位置
			// 每次操作要比较多少轮(n-1)？[内循环作为后面的遍历]   起始位置n和后面的比较
			for (int i = n+1; i < arr.length; i++) {// 1~7 2~7 3~7
				// 当起始位置大于后面的则需要交换
				if (arr[n] > arr[i]) {
					int item = arr[i];
					arr[i] = arr[n];
					arr[n] = item;
				}
			}
		}
//然后输出
		
		//方法二：找出最小的数值与首位交换~
		//定义一个索引，用于保存当前最小的数值的位置
		int index = 0;
		for (int n = 0; n < arr.length - 1; n++) {// 0~6  起始位置
			index = n;//初始化起始位置的索引
			// 每次操作要比较多少轮(n-i)？[内循环作为后面的遍历]   起始位置n和后面的比较
			for (int i = n+1; i < arr.length; i++) {// 1~7 2~7 3~7
				// 当后面的小于index位置的数值则将该索引赋值给index
				if (arr[i] < arr[index]) {
					index = i;
				}
			}
			//交换：把最小的和起始位置的数值进行交换
			int item = arr[n];
			arr[n] = arr[index];
			arr[index] = item;
		}

---

练习（二分查找）

import java.util.Arrays;
public class BinarySearchTest {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] arr = { 5, 101, 978, 43, 45, 64, 1, 65 };
		//使用工具类进行排序
		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));
		//实现二分查询逻辑操作
		int key = 45;
		//中间值索引
		int index = 0;
		//查询范围 
		int start = 0;
		int end = arr.length;
		//设置一个标志位：
		boolean isFind = false;
		//循环
		while(start<=end) {
			//计算中间索引
			index = (end+start)/2;
			//进行判断操作【==、>、<】
			if(key==arr[index]) {
				System.out.println("找到目标索引为："+index);
				//
				isFind = true;
				//结束
				break;
			}else if(arr[index]>key) {//缩小范围  
				end = index-1;
			}else {
				start = index+1;
			}
		}
		if(!isFind) {
			System.out.println("没有找到目标索引");
		}
	}
}

---

数组工具类的使用

数组工具类封装了数组的一些通用操作：

排序（升序）

		int[] arr = { 5, 101, 978, 43, 45, 64, 1, 65 };
		//是升序排序  [1, 5, 43, 45, 64, 65, 101, 978]
		Arrays.sort(arr);

---

复制（copyof）

		//拷贝数组
		int[] arr3 = Arrays.copyOf(arr, 3);
		System.out.println(Arrays.toString(arr3));
		
		//范围拷贝
		int[] arr4 = Arrays.copyOfRange(arr,1,5);
		System.out.println(Arrays.toString(arr4));	

---

查找（二分查找法【必须要升序排序】）

		//二分查找法：升序排序，再进行二分之一查询
		System.out.println(Arrays.binarySearch(arr, 165));
 
		//根据范围进行查询 二分查询
		System.out.println(Arrays.binarySearch(arr, 5, 7, 65));

---

填充（fill）

		//fill填充
		Arrays.fill(arr, 110);
		Arrays.fill(arr,1,5, 110);
		System.out.println(Arrays.toString(arr));
		System.out.println(Arrays.toString(arr2));

---

toString（转换为字符串）

int[] arr = { 5, 101, 978, 43, 45, 64, 1, 65 };     
        //toString将数组格式化为字符串
        System.out.println(Arrays.toString(arr));

---

equals （数组是否相等）

import java.util.Arrays;
//数组工具类的使用
public class ArraysTool {
	public static void main(String[] args) {
		int[] arr = { 5, 101, 978, 43, 45, 64, 1, 65 };
		//比较数组是否相等:长度相等、顺序相等
		System.out.println(Arrays.equals(arr, arr2));
	}
}

---